package com.sg.service.biz.app.nb;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.ObjectUtil;
import com.github.pagehelper.Page;
import com.sg.common.util.CommonFunctionHelper;
import com.sg.dto.biz.app.req.*;
import com.sg.dto.biz.app.res.*;
import com.wicket.okrapp.common.baseinfo.BaseInfoDO;
import com.wicket.okrapp.common.baseinfo.BaseInfoHolder;
import com.wicket.okrcomponent.common.annotations.BanAuto;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author ： 手工接入方法
 * @version 1.0
 * @since 2022/5/28 15:32
 */
@Service
public class NbTask {

    /**
     * code:multiCollectionRemoveExistingData
     * name:M-汇报任务生成集合去除已存在数据（特殊方法）
     * desc:undefined
     **/
    @BanAuto
    @Trace(operationName = "M-汇报任务生成集合去除已存在数据（特殊方法）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public GenerateCollectionRemoveExistingDataRespDto generateCollectionRemoveExistingData(GenerateCollectionRemoveExistingDataReqDto reqDto) {
        GenerateCollectionRemoveExistingDataRespDto retData = new GenerateCollectionRemoveExistingDataRespDto();
        if (CollUtil.isEmpty(reqDto.getVirtualOrgMemberList())) {
            return retData;
        }
        List<String> filteredList = new ArrayList<>(reqDto.getVirtualOrgMemberList());
        if (CollectionUtil.isNotEmpty(filteredList)) {
            filteredList = filteredList.stream().distinct().collect(Collectors.toList());
        }

        if (CollUtil.isNotEmpty(reqDto.getLiableVirtualOrgMemberList())) {
            for (String one : reqDto.getLiableVirtualOrgMemberList()) {
                filteredList.remove(one);
            }
        }
        if (CollUtil.isNotEmpty(reqDto.getDirectorVirtualOrgMemberList())) {
            for (String one : reqDto.getDirectorVirtualOrgMemberList()) {
                filteredList.remove(one);
            }
        }
        retData.setVirtualOrgMemberList(filteredList);
        return retData;
    }

    /**
     * code:getLastFromDataList
     * name:M3-取排序列表中上一条数据（特殊方法）
     * desc:undefined
     **/
    @Trace(operationName = "M3-取排序列表中上一条数据（特殊方法）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ObtainGetLastFromDataListRespDto obtainGetLastFromDataList(ObtainGetLastFromDataListReqDto reqDto) {
        ObtainGetLastFromDataListRespDto retData = new ObtainGetLastFromDataListRespDto();
        EvaObjTargetCycleReportSortDto lastData = new EvaObjTargetCycleReportSortDto();
        for (EvaObjTargetCycleReportSortDto oneData : reqDto.getEvaObjTargetCycleReportSortList()) {
            if (oneData.getEvaObjTargetCycleId().equals(reqDto.getEvaObjTargetCycleId())) {
                retData.setLastEvaObjTargetCycleId(lastData.getEvaObjTargetCycleId());
                break;
            }
            lastData = oneData;
        }
        return retData;
    }


    /**
     * code:timeEfficiencyCheck
     * name:M3-检查任务完成时间
     * desc:undefined
     **/
    @Trace(operationName = "M3-检查任务完成时间")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public CheckTimeScopeCheckRespDto checkTimeScopeCheck(CheckTimeScopeCheckReqDto reqDto) {
        CheckTimeScopeCheckRespDto retData = new CheckTimeScopeCheckRespDto();
        if (reqDto.getActualEndTime().getTime() < reqDto.getPlanEndTime().getTime()) {
            retData.setTimeCompareResult("BEFORE");
        } else if (reqDto.getActualEndTime().getTime() > reqDto.getPlanEndTime().getTime()) {
            retData.setTimeCompareResult("LATER");
        } else if (reqDto.getActualEndTime().getTime() == reqDto.getPlanEndTime().getTime()) {
            retData.setTimeCompareResult("PRESENT");
        }
        return retData;
    }

    /**
     * code:caluTimeDiff
     * name:M3-计算时间差（开始时间）
     * desc:undefined
     **/
    @Trace(operationName = "M3-计算时间差（开始时间）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public AddCaluDateDiffRespDto addCaluDateDiff(AddCaluDateDiffReqDto reqDto) {
        AddCaluDateDiffRespDto retData = new AddCaluDateDiffRespDto();
        int days = CommonFunctionHelper.differentDaysByString(reqDto.getCaluEndTime(), reqDto.getCaluStartTime());
        retData.setTimeDiffDays(String.valueOf(days));
        retData.setTimeDiff(String.valueOf(days * 24));
        return retData;
    }


    /**
     * code:objectToData
     * name:M执行图片单条转数据集
     * desc:undefined
     * gen by moon at 8/17/2022, 12:14:21 AM
     **/
    @Trace(operationName = "M执行图片单条转数据集")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ImplementPicSingleSetDataEntryRespDto implementPicSingleSetDataEntry(ImplementPicSingleSetDataEntryReqDto reqDto) {
        ImplementPicSingleSetDataEntryRespDto retData = new ImplementPicSingleSetDataEntryRespDto();
        if (ObjectUtil.isEmpty(reqDto) || ObjectUtil.isEmpty(reqDto.getDatasetField())) {
            return retData;
        }
        String[] fileList = reqDto.getDatasetField().split(",");
        if (ObjectUtil.isEmpty(fileList)) {
            return retData;
        }
        List<String> retList = Arrays.asList(fileList);
        List<String> retNewList = new ArrayList<>();
        for (String one : retList) {
            if (one.equals("--")) {
                continue;
            }
            retNewList.add(CommonFunctionHelper.getFilePath(one));
        }
        retData.setPicSingleSetDataEntryList(retNewList);
        return retData;
    }

    /**
     * code:findLevelCode
     * name:M-查询找祖先列表（特殊方法）
     * desc:undefined
     * gen by moon at 8/28/2022, 4:07:04 PM
     **/
    @Trace(operationName = "M-查询找祖先列表（特殊方法）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public QueryLookAncestorNodeListRespDto queryLookAncestorNodeList(QueryLookAncestorNodeListReqDto reqDto) {
        QueryLookAncestorNodeListRespDto retData = new QueryLookAncestorNodeListRespDto();
        String oriCode = null;
        if (reqDto.getEvaObjTargetCycleCode() != null && !reqDto.getEvaObjTargetCycleCode().isEmpty()) {
            oriCode = reqDto.getEvaObjTargetCycleCode();
        }

        if (reqDto.getAssistNodeTypeObjectCode() != null && !reqDto.getAssistNodeTypeObjectCode().isEmpty()) {
            oriCode = reqDto.getAssistNodeTypeObjectCode();
        }

        if (reqDto.getComCode() != null && !reqDto.getComCode().isEmpty()) {
            oriCode = reqDto.getComCode();
        }

        if (oriCode == null || oriCode.isEmpty()) {
            return retData;
        }
        int dealSize = 4;
        while (oriCode.length() >= dealSize) {
            String oneCode = oriCode.substring(0, dealSize);
            if (oneCode != null && !oneCode.isEmpty()) {
                EvaObjTargetCycleDto elm = new EvaObjTargetCycleDto();
                elm.setEvaObjTargetCycleCode(oneCode);
                retData.getEvaObjTargetCycleList().add(elm);
                retData.getLookAncestorNodeList().add(oneCode);
            }
            dealSize = dealSize + 4;
        }
        retData.getLookAncestorNodeList().remove(oriCode);
        return retData;
    }

    /**
     * code:getPublicFieldCache
     * name:M3-获取接收字段（特殊方法）
     * desc:undefined
     * gen by moon at 8/28/2022, 4:07:14 PM
     **/
    @Trace(operationName = "M3-获取接收字段（特殊方法）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ObtainReceiveFieldRespDto obtainReceiveField(ObtainReceiveFieldReqDto reqDto) {
        return BeanUtil.toBean(reqDto, ObtainReceiveFieldRespDto.class);
    }

    /**
     * code:publicFieldCache
     * name:M3更新公共字段缓存
     * desc:undefined
     * gen by moon at 8/28/2022, 4:07:23 PM
     **/
    @Trace(operationName = "M3更新公共字段缓存")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public RefreshPublicFieldCacheRespDto refreshPublicFieldCache(RefreshPublicFieldCacheReqDto reqDto) {
        if (BaseInfoHolder.contextHolder.get() != null) {
            BaseInfoHolder.contextHolder.remove();
        }
        BaseInfoDO domain = new BaseInfoDO();
        domain.setSpecSpaceId(reqDto.getSpaceId());
        domain.setSpecInductionRecordId(reqDto.getCreateInductionId());
        domain.setSpecAppId(reqDto.getAppId());
        CommonFunctionHelper.setBaseInfoToLocal(domain);
        return new RefreshPublicFieldCacheRespDto();
    }

    /**
     * code:dataToObject
     * name:M执行图片数据集转单条
     * desc:undefined
     * gen by moon at 9/6/2022, 10:10:22 PM
     **/
    @Trace(operationName = "M执行图片数据集转单条")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ImplementPicDataSetSingleEntryRespDto implementPicDataSetSingleEntry(ImplementPicDataSetSingleEntryReqDto reqDto) {
        ImplementPicDataSetSingleEntryRespDto retData = new ImplementPicDataSetSingleEntryRespDto();
        if (reqDto.getPicDataSetSingleEntryList() == null || reqDto.getPicDataSetSingleEntryList().size() == 0) {
            return retData;
        }
        String str = "";
        for (String one : reqDto.getPicDataSetSingleEntryList()) {
            str = one + "," + str;
        }
        retData.setDatasetField(str);
        String tmpStr = retData.getDatasetField().substring(0, retData.getDatasetField().length() - 1);
        retData.setDatasetField(tmpStr);
        return retData;
    }

    /**
     * code:specialMethodOutputPara
     * name:是否可以编辑
     * desc:undefined
     * gen by moon at 9/20/2022, 10:57:45 PM
     **/
    @Trace(operationName = "是否可以编辑")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ImplementOutputParametersRespDto implementOutputParameters(ImplementOutputParametersReqDto reqDto) {
        return BeanUtil.toBean(reqDto, ImplementOutputParametersRespDto.class);
    }

    /**
     * code:specialMethodOutputPara
     * name:第一行（进度值）是否显示
     * desc:undefined
     * gen by moon at 9/20/2022, 10:57:45 PM
     **/
    @Trace(operationName = "第一行（进度值）是否显示")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public AddOutputParametersRespDto addOutputParameters(AddOutputParametersReqDto reqDto) {
        return BeanUtil.toBean(reqDto, AddOutputParametersRespDto.class);
    }

    /**
     * code:publicFieldCache
     * name:M3执行业务应用公共字段推送内存（特殊方法）
     * desc:undefined
     * gen by moon at 9/22/2022, 12:01:05 AM
     **/
    @Trace(operationName = "M3执行业务应用公共字段推送内存（特殊方法）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ImplementBizPublicFieldPushMemoryRespDto implementBizPublicFieldPushMemory(ImplementBizPublicFieldPushMemoryReqDto reqDto) {
        BaseInfoDO domain = new BaseInfoDO();
        if (BaseInfoHolder.contextHolder.get() != null) {
            BeanUtil.copyProperties(BaseInfoHolder.contextHolder.get().getBaseInfo(), domain);
            BaseInfoHolder.contextHolder.remove();
        }
        if (reqDto.getSpaceId() != null) {
            domain.setSpecSpaceId(reqDto.getSpaceId());
        }

        if (reqDto.getCreateInductionId() != null) {
            domain.setSpecInductionRecordId(reqDto.getCreateInductionId());
        }

        if (reqDto.getAppId() != null) {
            domain.setSpecAppId(reqDto.getAppId());
        }

        if (reqDto.getHighestOrgID() != null) {
            domain.setSpecHighestOrgID(reqDto.getHighestOrgID());
        }

        if (reqDto.getUserId() != null) {
            domain.setSpecUserId(reqDto.getUserId());
        }

        if (reqDto.getOriginalRoleMemberId() != null) {
            domain.setSpecOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());
        }

        CommonFunctionHelper.setBaseInfoToLocal(domain);
        return new ImplementBizPublicFieldPushMemoryRespDto();
    }

    /**
     * code:publicFieldCache
     * name:M3执行业务应用业务字段推送内存（特殊方法）
     * desc:undefined
     * gen by moon at 9/22/2022, 12:03:28 AM
     **/
    @Trace(operationName = "M3执行业务应用业务字段推送内存（特殊方法）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ImplementBizBusinessFieldPushMemoryRespDto implementBizBusinessFieldPushMemory(ImplementBizBusinessFieldPushMemoryReqDto reqDto) {
        // TODO ruizhe skai dong ; 9/22/2022, 12:03:28 AM
        //应用字段推缓存
        return new ImplementBizBusinessFieldPushMemoryRespDto();
    }

    /**
     * code:receptionService
     * name:M3执行业务应用构造出入参字段（特殊方法）
     * desc:undefined
     * gen by moon at 12/9/2022, 1:46:00 PM
     **/
    @Trace(operationName = "M3执行业务应用构造出入参字段（特殊方法）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ImplementBizConstructAccessParameterFieldRespDto implementBizConstructAccessParameterField(ImplementBizConstructAccessParameterFieldReqDto reqDto) {
        return BeanUtil.toBean(reqDto, ImplementBizConstructAccessParameterFieldRespDto.class);
    }

    /**
     * code:receptionService
     * name:M3获取接收外部字段(特殊方法）
     * desc:undefined
     * gen by moon at 12/16/2022, 5:54:03 PM
     **/
    @Trace(operationName = "M3获取接收外部字段(特殊方法）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ObtainReceiveOutFieldRespDto obtainReceiveOutField(ObtainReceiveOutFieldReqDto reqDto) {
        return BeanUtil.toBean(reqDto, ObtainReceiveOutFieldRespDto.class);
    }

    /**
     * code:collectionsIntersectionsData
     * name:当前评价人可参与评价的角色列表
     * desc:undefined
     * gen by moon at 12/18/2022, 4:10:14 PM
     **/
    @Trace(operationName = "当前评价人可参与评价的角色列表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ObtainCollectionsIntersectionsDataRespDto obtainCollectionsIntersectionsData(ObtainCollectionsIntersectionsDataReqDto reqDto) {
        ObtainCollectionsIntersectionsDataRespDto retData = new ObtainCollectionsIntersectionsDataRespDto();
        for (String one : reqDto.getCollectionsIntersectionsDataAList()) {
            if (reqDto.getCollectionsIntersectionsDataBList().contains(one)) {
                retData.getCollectionsIntersectionsDataList().add(one);
            }
        }
        return retData;
    }

    /**
     * code:receptionService
     * name:M3约定是否向上计算为“1”
     * desc:undefined
     * gen by moon at 2/16/2023, 10:08:09 PM
     **/
    @Trace(operationName = "M3约定是否向上计算为“1”")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ImplementAccessParameterBizFieldRespDto implementAccessParameterBizField(ImplementAccessParameterBizFieldReqDto reqDto) {
        return BeanUtil.toBean(reqDto, ImplementAccessParameterBizFieldRespDto.class);
    }

    /**
     * code:receptionService
     * name:M3约定审核权限为“1”
     * desc:undefined
     * gen by moon at 3/23/2023, 5:05:17 PM
     **/
    @Trace(operationName = "M3约定审核权限为“1”")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ImplementAcceptFieldRespDto implementAcceptField(ImplementAcceptFieldReqDto reqDto) {
        return BeanUtil.toBean(reqDto, ImplementAcceptFieldRespDto.class);
    }

    /**
     * code:receptionService
     * name:约定：是
     * desc:undefined
     * gen by moon at 6/1/2023, 2:40:31 AM
     **/
    @Trace(operationName = "约定：是")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public CalculateAcceptAboveFieldsRespDto calculateAcceptAboveFields(CalculateAcceptAboveFieldsReqDto reqDto) {
        return BeanUtil.toBean(reqDto, CalculateAcceptAboveFieldsRespDto.class);
    }

    /**
     * code:receptionService
     * name:提示：请录入该目标的进度、实际值
     * desc:undefined
     * gen by moon at 10/4/2023, 12:35:41 AM
     **/
    @Trace(operationName = "提示：请录入该目标的进度、实际值")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ImplementAcceptFieldByStandardDataRespDto implementAcceptFieldByStandardData(ImplementAcceptFieldByStandardDataReqDto reqDto) {
        return BeanUtil.toBean(reqDto, ImplementAcceptFieldByStandardDataRespDto.class);

    }

    /**
     * code:objectToData
     * name:M执行图片多条转数据集
     * desc:undefined
     * gen by moon at 10/22/2023, 4:00:59 PM
     **/
    @Trace(operationName = "M执行图片多条转数据集")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ImplementPicMultipleSetDataEntryRespDto implementPicMultipleSetDataEntry(ImplementPicMultipleSetDataEntryReqDto reqDto) {
        ImplementPicMultipleSetDataEntryRespDto retData = new ImplementPicMultipleSetDataEntryRespDto();
        if (reqDto.getPicMultipleSetDataEntryList() == null || reqDto.getPicMultipleSetDataEntryList().size() <= 0) {
            return retData;
        }
        for (PicMultipleSetDataEntryDto oneSrc : reqDto.getPicMultipleSetDataEntryList()) {
            if (oneSrc.getDatasetField() != null && !oneSrc.getDatasetField().isEmpty()) {
                String[] fileListSplit = oneSrc.getDatasetField().split(",");
                if (fileListSplit != null && fileListSplit.length > 0) {
                    for (String oneFile : fileListSplit) {
                        if (oneFile.equals("--")) {
                            continue;
                        }
                        PicMultipleSetDataEntryDto elm = new PicMultipleSetDataEntryDto();
                        elm.setCycleStageDataId(oneSrc.getCycleStageDataId());
                        elm.setDatasetPrimarykey(CommonFunctionHelper.getFilePath(oneFile));
                        retData.getPicMultipleSetDataEntryList().add(elm);
                    }
                }
            }
        }
        return retData;
    }

    /**
     * code:obtainPageTotals
     * name:M3-执行获取分页总条数（特殊方法）
     * desc:undefined
     * gen by moon at 12/8/2023, 11:21:23 AM
     **/
    @Trace(operationName = "M3-执行获取分页总条数（特殊方法）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ImplementObtainPageTotalsRespDto implementObtainPageTotals(ImplementObtainPageTotalsReqDto reqDto) {
        ImplementObtainPageTotalsRespDto retData = new ImplementObtainPageTotalsRespDto();
        retData.setTotals(0L);
        Page<?> page = CommonFunctionHelper.getBaseInfoFromLocal().getPageInfo();
        if (page != null) {
            retData.setTotals(page.getTotal());
        }
        return retData;
    }

    /**
     * code:receptionService
     * name:M3约定为待汇报
     * desc:undefined
     * gen by moon at 12/28/2023, 7:14:58 PM
     **/
    @Trace(operationName = "M3约定为待汇报")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ImplementSendMsgReceiverAcceptFieldRespDto implementSendMsgReceiverAcceptField(ImplementSendMsgReceiverAcceptFieldReqDto reqDto) {
        return BeanUtil.toBean(reqDto, ImplementSendMsgReceiverAcceptFieldRespDto.class);
    }

    /**
     * code:receptionService
     * name:M3执行第四接收字段（特殊方法）
     * desc:undefined
     * gen by moon at 1/1/2024, 9:16:00 PM
     **/
    @Trace(operationName = "M3执行第四接收字段（特殊方法）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ImplementFourthReceivingFieldRespDto implementFourthReceivingField(ImplementFourthReceivingFieldReqDto reqDto) {
        return BeanUtil.toBean(reqDto, ImplementFourthReceivingFieldRespDto.class);
    }

    /**
     * code:receptionService
     * name:出参：同级兄弟汇报任务完成情况
     * desc:undefined
     * gen by moon at 2/17/2024, 9:17:29 AM
     **/
    @Trace(operationName = "出参：同级兄弟汇报任务完成情况")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ImplementFiveReceivingFieldRespDto implementFiveReceivingField(ImplementFiveReceivingFieldReqDto reqDto) {
        return BeanUtil.toBean(reqDto, ImplementFiveReceivingFieldRespDto.class);
    }

    /**
     * code:receptionService
     * name:M3约定数据对象批次标识
     * desc:undefined
     * gen by moon at 4/30/2024, 1:47:55 PM
     **/
    @Trace(operationName = "M3约定数据对象批次标识")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ImplementEightReceivingFieldRespDto implementEightReceivingField(ImplementEightReceivingFieldReqDto reqDto) {
        return BeanUtil.toBean(reqDto, ImplementEightReceivingFieldRespDto.class);
    }

    /**
     * code:receptionService
     * name:M3-约定字段：是、否
     * desc:undefined
     * gen by moon at 6/21/2024, 3:43:54 PM
     **/
    @Trace(operationName = "M3-约定字段：是、否")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ImplementElevenReceivingFieldRespDto implementElevenReceivingField(ImplementElevenReceivingFieldReqDto reqDto) {
        return BeanUtil.toBean(reqDto, ImplementElevenReceivingFieldRespDto.class);
    }
    //手工接入方法
}
